bind_test.go (1)

22-29: Approve the new test function with a suggestion.

The new Test_returnErr function is a good addition to test the fix for the nil pointer dereference issue. It correctly checks that no error is returned when a nil error is passed to returnErr.

To make the test more robust, consider adding an additional assertion to check the response status code:

 err := c.Bind().Must().returnErr(nil)
 require.Equal(t, nil, err)
+require.Equal(t, 200, c.Response().StatusCode())

This will ensure that not only is no error returned, but also that the response status remains unchanged when a nil error is passed.

Configuration used: CodeRabbit UI
Review profile: CHILL

bind.go (1)

43-43: Update documentation for Custom binding

The comment "NOTE: Should/Must is still valid for Custom binders" above the Custom method is now outdated since Should/Must methods have been removed.

Remove or update the comment to reflect the new error handling approach.

Configuration used: CodeRabbit UI
Review profile: CHILL

binder/README.md (2)

86-88: LGTM! Consider enhancing the description.

The section title change from "Must" to "WithAutoHandling" better reflects the method's purpose. However, the description could be more explicit about what "handle it automatically" means.

Consider this revision for clarity:

-Normally, Fiber returns binder error directly. However; if you want to handle it automatically, you can prefer `WithAutoHandling()`.
+Normally, Fiber returns binder errors directly to your handler. However, if you want Fiber to automatically set a 400 status code and return the error message to the client, you can use `WithAutoHandling()`.

---

102-102: LGTM! Consider enhancing the example.

The code example correctly demonstrates the new WithAutoHandling() method.

Consider adding another example showing successful binding to better illustrate the difference:

// Success case:
// curl -X GET -H "Content-Type: application/json" --data "{\"name\":\"john\",\"pass\":\"doe\"}" localhost:3000

// Error case (as shown):
// curl -X GET -H "Content-Type: application/json" --data "{\"pass\":\"doe\"}" localhost:3000

docs/api/bind.md (2)

442-448: Enhance the WithAutoHandling documentation

The documentation for WithAutoHandling could be more comprehensive. Consider adding:

1. A clear example showing both success and error scenarios
2. Clarification of what happens when binding succeeds
3. Comparison with the Should method to help users choose between them

Here's a suggested enhancement:

 ### WithAutoHandling
 
-If you want to handle binder errors automatically, you can use WithAutoHandling.
-If there's an error it'll return error and 400 as HTTP status.
+If you want to handle binder errors automatically, you can use WithAutoHandling.
+If there's an error, it'll return the error and set 400 as the HTTP status.
+On success, it continues with the normal flow.
+
+```go title="Example"
+app.Post("/", func(c fiber.Ctx) error {
+    p := new(Person)
+    
+    // Automatically returns 400 on binding errors
+    if err := c.Bind().WithAutoHandling().JSON(p); err != nil {
+        return err // Error is already handled
+    }
+    
+    return c.JSON(p) // Success case
+})
+```
 
 ```go title="Signature"
 func (b *Bind) WithAutoHandling() *Bind

<details>
<summary>🧰 Tools</summary>

<details>
<summary>🪛 LanguageTool</summary>

[uncategorized] ~445-~445: A comma might be missing here.
Context: ...can use WithAutoHandling. If there's an error it'll return error and 400 as HTTP stat...

(AI_EN_LECTOR_MISSING_PUNCTUATION_COMMA)

</details>

</details>

---

`445-445`: **Fix grammar: Add missing comma**

Add a comma after the conditional clause for better readability.


```diff
-If there's an error it'll return error and 400 as HTTP status.
+If there's an error, it'll return error and 400 as HTTP status.

🧰 Tools

🪛 LanguageTool

[uncategorized] ~445-~445: A comma might be missing here.
Context: ...can use WithAutoHandling. If there's an error it'll return error and 400 as HTTP stat...

(AI_EN_LECTOR_MISSING_PUNCTUATION_COMMA)

bind_test.go (1)

Line range hint 1628-1641: Consider adding more test cases for comprehensive coverage.

While the test effectively verifies error handling with WithAutoHandling, consider adding test cases for:

1. Successful binding scenarios
2. Different types of binding errors
3. Edge cases with empty or invalid data

This would ensure the new WithAutoHandling functionality is thoroughly tested.

Example additional test case:

 func Test_Bind_WithAutoHandling(t *testing.T) {
     app := New()
     c := app.AcquireCtx(&fasthttp.RequestCtx{})
 
     type RequiredQuery struct {
         Name string `query:"name,required"`
     }
     rq := new(RequiredQuery)
+    
+    // Test successful binding
+    c.Request().URI().SetQueryString("name=john")
+    err := c.Bind().WithAutoHandling().Query(rq)
+    require.NoError(t, err)
+    require.Equal(t, "john", rq.Name)
+    require.Equal(t, StatusOK, c.Response().StatusCode())
+    
+    // Test error case
     c.Request().URI().SetQueryString("")
     err := c.Bind().WithAutoHandling().Query(rq)
     require.Equal(t, StatusBadRequest, c.Response().StatusCode())
     require.Equal(t, "Bad request: bind: name is empty", err.Error())
 }

Configuration used: CodeRabbit UI
Review profile: CHILL

docs/api/bind.md (1)

461-467: Enhance the WithAutoHandling documentation

The documentation for the WithAutoHandling method could be improved by:

1. Adding a code example demonstrating its practical usage
2. Explaining when to use this method vs. Should
3. Clarifying the specific error scenarios it handles

Consider adding this example:

+```go title="Example"
+app.Post("/", func(c fiber.Ctx) error {
+    p := new(Person)
+    
+    // WithAutoHandling will automatically return 400 Bad Request on binding errors
+    return c.Bind().WithAutoHandling().JSON(p)
+})
+```
+
+The key differences between `WithAutoHandling` and `Should`:
+- `WithAutoHandling`: Automatically handles binding errors by returning them with 400 status
+- `Should`: Allows manual error handling (default behavior)

Configuration used: CodeRabbit UI
Review profile: CHILL

docs/api/bind.md (1)

461-468: Improve clarity and fix grammatical error

1. Fix the grammatical error: "therefor" should be "therefore"
2. Consider adding more details about error handling behavior

 ### WithAutoHandling
 
 If you want to handle binder errors automatically, you can use `WithAutoHandling`.  
 If there's an error, it will return the error and set HTTP status to `400 Bad Request`.
-This function does NOT panic therefor you must still return on error explicitly
+This function does NOT panic therefore you must still return on error explicitly. It safely handles
+all error cases, including nil errors.
 
 ```go title="Signature"
 func (b *Bind) WithAutoHandling() *Bind

🧰 Tools

🪛 LanguageTool

[grammar] ~465-~465: Did you mean to write ‘therefore’?
Context: ... Request`. This function does NOT panic therefor you must still return on error explicit...

(THEREFORE)

Configuration used: CodeRabbit UI
Review profile: CHILL

binder/README.md (4)

86-86: Clarify WithAutoHandlingWithStatus in the documentation

The section title mentions "WithAutoHandlingWithStatus", but this method is not explained or demonstrated in the documentation. Consider either:

1. Adding documentation for WithAutoHandlingWithStatus, or
2. Removing it from the title if it's not yet implemented

---

Line range hint 88-102: Improve documentation clarity and examples

Several improvements could enhance the documentation:

1. The example uses GET with a request body, which is not a common RESTful practice. Consider using POST instead:

-app.Get("/", func(c fiber.Ctx) error {
+app.Post("/", func(c fiber.Ctx) error {

2. Add an explicit example of the error response format:

// Error Response Example:
// {
//   "error": "Bad request: name is empty"
// }

3. Clarify the automatic error handling behavior:

-If there's an error it'll return error and 400 as HTTP status.
+If there's a validation error or binding failure, it automatically sets a 400 HTTP status code and returns an error response.

4. Document the nil error handling improvement:

// Note: WithAutoHandling safely handles nil errors during binding,
// preventing potential panics in the error handling chain.

🧰 Tools

🪛 LanguageTool

[uncategorized] ~90-~90: A comma might be missing here.
Context: ...er WithAutoHandling(). If there's an error it'll return error and 400 as HTTP stat...

(AI_EN_LECTOR_MISSING_PUNCTUATION_COMMA)

---

[uncategorized] ~90-~90: The preposition “of” seems more likely in this position.
Context: ...d 400 as HTTP status. Here's an example for it: ```go // Field names should start ...

(AI_EN_LECTOR_REPLACEMENT_PREPOSITION)

---

102-102: Consider adding error handling examples

The example could be enhanced to show different error scenarios and their handling:

// Example 1: Missing required field
c.Bind().WithAutoHandling().JSON(p)
// Result: 400 Bad Request - "name is empty"

// Example 2: Invalid JSON
c.Bind().WithAutoHandling().JSON(p)
// Result: 400 Bad Request - "invalid JSON format"

// Example 3: Successful binding
c.Bind().WithAutoHandling().JSON(p)
// Result: Continues execution normally

---

Documentation needs update: WithAutoHandlingWithStatus method doesn't exist

The documentation in binder/README.md mentions "WithAutoHandling/WithAutoHandlingWithStatus" in its heading and content, but the codebase only implements WithAutoHandling(). The actual implementation shows that WithAutoHandling() sets the status code to 400 on error, making the separate "WithStatus" variant unnecessary or removed.

• Remove references to "WithAutoHandlingWithStatus" from the documentation heading and content in binder/README.md
• The rest of the documented behavior for WithAutoHandling() is accurate, including the 400 status code and error handling

🔗 Analysis chain

Line range hint 86-102: Verify documentation consistency with implementation

Let's ensure the documentation accurately reflects the implemented method names and behaviors.

---

Let me gather more specific information about the binding implementation.

🏁 Scripts executed

The following scripts were executed for the analysis:

Script:

#!/bin/bash
# Description: Verify method names and signatures in the codebase

# Check for old method names to ensure complete migration
echo "Checking for any remaining references to old method names..."
rg -i "Must\(\)" --type go
rg -i "Should\(\)" --type go

# Verify new method signatures
echo "Verifying new method signatures..."
ast-grep --pattern 'func $_(c *Ctx) Bind() *Bind {
  $$$
}'

# Check for any remaining references to WithAutoHandlingWithStatus
echo "Checking WithAutoHandlingWithStatus references..."
rg -i "WithAutoHandlingWithStatus"

Length of output: 553

---

Script:

#!/bin/bash
# Search for WithAutoHandling implementation and usage
echo "Checking WithAutoHandling implementation..."
rg -A 5 "WithAutoHandling"

# Search for binding-related structs and methods
echo "Checking Bind struct and methods..."
ast-grep --pattern 'type Bind struct {
  $$$
}'

# Look for actual binding implementation
echo "Looking for binding implementation..."
ast-grep --pattern 'func (b *Bind) JSON($_) error {
  $$$
}'

Length of output: 4003

🧰 Tools

🪛 LanguageTool

[uncategorized] ~90-~90: A comma might be missing here.
Context: ...er WithAutoHandling(). If there's an error it'll return error and 400 as HTTP stat...

(AI_EN_LECTOR_MISSING_PUNCTUATION_COMMA)

---

[uncategorized] ~90-~90: The preposition “of” seems more likely in this position.
Context: ...d 400 as HTTP status. Here's an example for it: ```go // Field names should start ...

(AI_EN_LECTOR_REPLACEMENT_PREPOSITION)

bind.go (2)

34-41: Consider enhancing the documentation

While the rename to WithAutoHandling is good, consider making the documentation more explicit about nil error handling to prevent future confusion.

- // If you want to handle binder errors automatically, you can use `WithAutoHandling`.  
- // If there's an error, it will return the error and set HTTP status to `400 Bad Request`.
- // You must still return on error explicitly
+ // WithAutoHandling configures automatic error handling for binding operations.
+ // When an error occurs:
+ // 1. Sets HTTP status to 400 Bad Request
+ // 2. Returns a formatted error message
+ // When no error occurs (nil error):
+ // 1. Returns nil without modifying the response
+ // Note: You must still handle the returned error in your code

🧰 Tools

🪛 golangci-lint

34-34: File is not goimports-ed

(goimports)

---

34-34: File is not gofumpt-ed with -extra

(gofumpt)

---

66-66: Fix typo in documentation

There's a typo in the note: "WithAutoHandling/WithAutoHandling" should be "WithAutoHandling/WithoutAutoHandling".

- // NOTE: WithAutoHandling/WithAutoHandling is still valid for Custom binders.
+ // NOTE: WithAutoHandling/WithoutAutoHandling is still valid for Custom binders.

docs/api/bind.md (1)

465-465: Fix grammar in documentation

There are two grammar issues in this line:

1. "therefor" should be "therefore"
2. Missing comma before "therefore"

-This function does NOT panic therefor you must still return on error explicitly
+This function does NOT panic, therefore you must still return on error explicitly

🧰 Tools

🪛 LanguageTool

[uncategorized] ~465-~465: Possible missing comma found.
Context: ...00 Bad Request`. This function does NOT panic therefor you must still return on error...

(AI_HYDRA_LEO_MISSING_COMMA)

---

[grammar] ~465-~465: Did you mean to write ‘therefore’?
Context: ... Request`. This function does NOT panic therefor you must still return on error explicit...

(THEREFORE)

Configuration used: CodeRabbit UI
Review profile: CHILL

#!/bin/bash
# Search for any remaining references to the old method names
echo "Checking for old method names..."
rg -l "\.Must\(\)" --type go
rg -l "\.Should\(\)" --type go

# Search for new method names to confirm updates
echo "Verifying new method names..."
rg -l "\.WithAutoHandling\(\)" --type go
rg -l "\.WithoutAutoHandling\(\)" --type go

#!/bin/bash
# Let's check the actual usage context of these methods
echo "Checking WithAutoHandling usage context:"
rg "\.WithAutoHandling\(\)" -B 2 -A 2 --type go

echo -e "\nChecking test file content for better context:"
cat bind_test.go

 If you want to handle binder errors automatically, you can use `WithAutoHandling`.  
-If there's an error, it will return the error and set HTTP status to `400 Bad Request`.
+If there's an error, it will return the error and set HTTP status to `400 Bad Request`. This method
+safely handles all error cases, including nil errors, preventing potential panics that could occur
+when using error handling methods.
+
+:::note
+This method replaces the previous `Must` method and includes improved error handling to prevent
+nil pointer dereference issues.
+:::

bind.go (2)

34-37: Enhance documentation for clarity

While the documentation is good, consider adding examples to illustrate proper usage, especially regarding the note about explicit error returns.

Example addition:

 // If you want to handle binder errors automatically, you can use `WithAutoHandling`.  
 // If there's an error, it will return the error and set HTTP status to `400 Bad Request`.
 // You must still return on error explicitly
+//
+// Example:
+//  if err := c.Bind().WithAutoHandling().JSON(&data); err != nil {
+//    return err // Required: must explicitly return the error
+//  }

🧰 Tools

🪛 golangci-lint (1.61.0)

34-34: File is not gofumpt-ed with -extra

(gofumpt)

---

66-66: Fix typo in documentation

There's a typo in the comment:

-// NOTE: WithAutoHandling/WithAutoHandling is still valid for Custom binders.
+// NOTE: WithAutoHandling/WithoutAutoHandling is still valid for Custom binders.

ctx.go (1)

1863-1864: Field rename looks good, but fix formatting

The rename from should to dontHandleErrs improves clarity and aligns with the nil pointer dereference fix. However, there's a minor formatting issue.

Fix the extra spaces after the colon:

-			ctx       : c,
-			dontHandleErrs: true,
+			ctx: c,
+			dontHandleErrs: true,

🧰 Tools

🪛 golangci-lint (1.61.0)

1863-1863: File is not gofumpt-ed with -extra

(gofumpt)

---

1863-1863: File is not goimports-ed

(goimports)

Configuration used: CodeRabbit UI
Review profile: CHILL

 b.ctx.Status(StatusBadRequest)
-return NewError(StatusBadRequest, "Bad request: "+err.Error())
+// Log the detailed error for debugging
+b.ctx.App().Logger().Error(err)
+// Return a generic error message to the client
+return NewError(StatusBadRequest, "Invalid request format")

#!/bin/bash
# Search for any remaining usage of old method names
echo "Checking for old method names..."
rg -l "\.Must\(\)" --type go
rg -l "\.Should\(\)" --type go

# Search for usage of new method names to ensure proper adoption
echo "Checking new method usage..."
rg -l "\.WithAutoHandling\(\)" --type go
rg -l "\.WithoutAutoHandling\(\)" --type go

#!/bin/bash
# Let's check the actual usage context of these methods
echo "Checking WithAutoHandling usage context..."
rg "\.WithAutoHandling\(\)" -B 2 -A 2 --type go

echo "Checking if there are any other similar method patterns in bind.go..."
rg "func.*Bind.*\)" bind.go

# Let's also check test coverage to ensure the new methods are properly tested
echo "Checking test coverage..."
cat bind_test.go

bind.go (1)

66-66: Fix typo in documentation.

The comment has a duplicate "WithAutoHandling". It should be "WithAutoHandling/WithoutAutoHandling".

-// NOTE: WithAutoHandling/WithAutoHandling is still valid for Custom binders.
+// NOTE: WithAutoHandling/WithoutAutoHandling is still valid for Custom binders.

Configuration used: CodeRabbit UI
Review profile: CHILL

 func (b *Bind) returnErr(err error) error {
 	if err == nil || b.dontHandleErrs {
 		return err
 	}
 
 	b.ctx.Status(StatusBadRequest)
-	return NewError(StatusBadRequest, "Bad request: "+err.Error())
+	b.ctx.App().Logger().Error(err)
+	return NewError(StatusBadRequest, "Invalid request format")
 }

#!/bin/bash
# Search for any remaining references to old method names
echo "Checking for old method names..."
rg -i "\.Must\(\)" || echo "No .Must() calls found"
rg -i "\.Should\(\)" || echo "No .Should() calls found"

# Search for examples and tests that might need updating
echo "Checking for potential test files..."
fd -e test.go | xargs rg -l "Must|Should"

#!/bin/bash
# Check the actual content of files that matched
echo "Checking content of matched files..."
for file in app_test.go ctx.go path.go middleware/rewrite/rewrite.go middleware/redirect/redirect.go middleware/adaptor/adaptor_test.go ctx_test.go client/request_test.go binder/mapping.go client/hooks.go; do
    if [ -f "$file" ]; then
        echo "=== $file ==="
        rg -C 2 "\.Must\(\)|\.Should\(\)" "$file" || echo "No exact method calls found"
    fi
done

# Also check for any WithoutAutoHandling or WithAutoHandling usage
echo -e "\nChecking for new method usage..."
rg "WithoutAutoHandling|WithAutoHandling"

#!/bin/bash
# Verify all usages of the new field name and ensure correct boolean logic
ast-grep --pattern 'dontHandleErrs'

#!/bin/bash
# Let's check the usage context of dontHandleErrs more thoroughly
rg "dontHandleErrs" -B 3 -A 3

# Also check for the old field name 'should' to compare the logic
rg "should" -B 3 -A 3 --type go

# Let's also see the full Bind struct definition
ast-grep --pattern 'type Bind struct {
  $$$
}'

#!/bin/bash
# Let's check the methods that use dontHandleErrs to verify the logic
ast-grep --pattern 'func ($b *Bind) $$$() $$ {
  $$$
  dontHandleErrs
  $$$
}'

# Also check for any error handling related methods
rg "returnErr" -A 5 -B 5